Test language conversion method

ABSTRACT

A method of converting test vectors in an original cycle based test language into a target cycle based test language, by forming a set of templates depicting waveforms defined in the target test language, decomposing a waveform in the original test language into a set of constituent events where each event includes data showing at least a starting value and a number of subsequent edges of the waveform, comparing the template and the set of constituent events at different levels of abstraction determined in advance, in the order of a signal level, a wave kind level where the signal is configured by a plurality of wave kinds, and a character level where the wave kind is configured by a plurality of characters, and storing the waveform data in the target test language when a match is detected and retrieving corresponding parameters of the waveform in the original test language.

This application claims benefit of Provisional Application No.60/156,121, filed Sep. 25, 1999.

FIELD OF THE INVENTION

This invention relates to a test data conversion method for testingsemiconductor devices by automatic test equipment, and moreparticularly, to a method of converting digital test vectors written inSTIL (Standard Test Interface Language) to digital test vectors of atest language unique to the automatic test equipment.

BACKGROUND OF THE INVENTION

In testing semiconductor devices such as ICs and LSIs by automatic testequipment (ATE) or an IC tester, a semiconductor IC device to be testedis provided with test signals or test patterns produced by an IC testerat its appropriate pins at predetermined test timings. The IC testerreceives output signals from the IC device under test in response to thetest signals. The output signals are strobed or sampled by strobesignals generated by the IC tester with predetermined timings to becompared with expected data to determine whether the IC device functionscorrectly or not. Typically, timings of the test signals and strobesignals are defined relative to a start timing of each test cycle of ICtester.

As noted above, an IC tester generates test patterns and strobes, i.e.,test vector, based on digital test vector data described in a language(format) unique to the tester. Such languages for automatic testequipment are different from manufacturer to manufacturer.

Recently, IEEE has proposed a test language STIL (Standard TestInterface Language) as a standard test interface language (IEEE Std1450-1999). STIL provides an interface between computer-aidedengineering (CAE) such as a logic test simulator and automatic testequipment. In a CAE environment or an EDA (electronic design automation)environment, a semiconductor device is designed with the aid of computersystem and such design is tested through a logic test simulator or atestbench. It is preferable to utilize the digital test vectors resultedfrom the logic simulation in testing actual semiconductor devices by ICtesters. STIL is designed to facilitate the transfer of large volumes ofdigital test vectors from CAE environment to the automatic testequipment (ATE) environment.

The STIL test language has recently become a standard. At present,however, most ATE systems do not use STIL as a native language. Suchnative languages provided by test equipment manufacturers are notcompatible to one another. Accordingly, there is a need to effectivelyconvert STIL to the ATE native language.

SUMMARY OF THE INVENTION

It is, therefore, an object of the present invention to provide a methodof converting digital test vectors of one cycle based test language toanother cycle based test language with high efficiency and accuracy.

It is another object of the present invention to provide a test languageconversion method of converting test vectors in a STIL (Standard TestInterface Language) format into a target format with high efficiency andaccuracy.

In the present invention, the method of converting test vectors in anoriginal cycle based test language into a target cycle based testlanguage, comprising the following steps of: reading available waveformsdefined in the target test language and forming a set of templatesdepicting the waveforms where each template corresponds to a waveform ofthe target test language and includes data showing at least a startingvalue of a segment of waveform and a number of subsequent edges in thewaveform; reading the test vectors of the original test language anddecomposing a waveform in the test vectors in the original test languageinto a set of constituent events where each event includes data showingat least a starting value and a number of subsequent edges of thewaveform; comparing the template derived from the waveform in the targettest language and the set of events derived from the original testlanguage; storing the waveform data in the target test language when amatch is detected in the comparison step and retrieving correspondingparameters of the waveform in the test vectors of original test languageand storing the parameters in combination with the matched waveformdata; and repeating the above steps for all of the test vectors in theoriginal test language, thereby forming a test vector file of the targettest language.

Typically, the original test language is STIL (Standard Test InterfaceLanguage) specified by IEEE Std 1450-1999. Preferably, the step ofcomparing the template and the set of events includes a step of changingdifferent levels of test vectors, in the order of a signal level, awavekind level where the signal is configured by a plurality ofwavekinds, a character level where the wavekind is configured by aplurality of characters.

The set of events derived from the original test language is stored in atable format having columns assigned to the data showing the number ofsubsequent edges and the starting value. The table storing the set ofevents is optimized by studying the starting value of a particular eventbased on an ending state produced by the previous event, therebysimplifying the data in the table.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a diagram showing an example of format in STIL which describessignals or signal groups in the digital test vectors which constituteintended test vectors.

FIG. 2 is a diagram showing an example of format in STIL which describestimings of edge in each of the signals constituting the waveforms.

FIG. 3 is a diagram showing an example of format in STIL which describespatterns of vectors in each of the signals constituting the waveforms.

FIG. 4 is a diagram showing an example of format in STIL which describesa flow of patterns in the test vectors constituting the intendedwaveforms.

FIG. 5 is a diagram showing an example of format in TDL (TestDescription Language) which is a test language native to ATE systemdeveloped by the assignee of this invention.

FIG. 6A is a schematic diagram showing a basic principle of testlanguage conversion in accordance with the present invention, and FIG.6B is a schematic diagram showing an example of functional configurationin the test language conversion of the present invention.

FIG. 7 is a diagram showing an example of STIL construct and anequivalent TDL representation, and a template of waveform based on theTDL representation.

FIG. 8 is a diagram showing other examples of STIL constructs, waveformscorresponding to the STIL constructs, and the TDL representations.

FIG. 9 is a diagram showing further examples of STIL constructs,waveforms corresponding to the STIL constructs, and the TDLrepresentations for explaining the optimization waveforms.

FIGS. 10A and 10B are tables showing examples of array depictingstarting values and number of edges which represent decomposed events inthe STIL test vectors for conducting the pattern match of the presentinvention.

FIG. 11 is a flow diagram showing an example of procedure in thewavekind matching of the present invention in the different levels oftest vectors.

FIG. 12 is a flow diagram showing an example of procedure in thewavekind matching of the present invention from the previous cycle tothe next cycle.

FIG. 13 is a diagram showing a basic idea of converting the STIL testvectors to multi-clock test signals of TDL when types of DUT pin areappropriate to such multi-clock signals.

FIG. 14 is a waveform diagram showing a basic idea of converting theSTIL test vectors to the pin multiplexing test vectors of TDL.

DETAILED DESCRIPTIONS OF THE PREFERRED EMBODIMENTS

The STIL (Standard Test Interface Language) testing language definespattern and timing information for device testing using a cycle-basedrepresentation. The format used does not represent the language of anyATE systems, but has been constructed to provide the maximum flexibilityin designing test programs. STIL has only recently been adopted as astandard and is not yet in widespread use. A number of STIL-basedapplications have been proposed in recent years, including general testflow, scan test methodology and ATPG (automatic test pattern generator).Currently, most ATE systems do not use STIL as a native language.Consequently, there is a need to convert from STIL to the nativelanguage of the target ATE system. This language is usually cycle-based,so the conversion is from one cycle-based representation to another.

In this patent specification, the inventor discloses some of the basicsteps involved in conversion method from one cycle-based format toanother cycle-based format. The inventor also presents some tricks thatallow the conversion of STIL in an efficient manner. The conversionsshown in this invention are based on an analysis of the data presentedin STIL. As a sample target language, Test Description Language (TDL)developed by Advantest Corporation, Tokyo, Japan, an assignee of thisinvention, is used for illustration purposes although the principlespresented are general and thus equally applicable to other testlanguages.

FIGS. 1–4 show examples of format in STIL for describing the digitaltest vectors. FIG. 1 shows formats of signals and signal groups, FIG. 2shows formats of timings of edges in each signal. FIG. 3 shows anexample of STIL format describing patterns of test vectors, and FIG. 4shows an example of STIL format describing the flow of patterns. FIG. 5is a diagram showing an example of format in TDL which is a target testlanguage.

Template Matching

The conversion from one cycle-based representation to another is mosteasily accomplished using an event based intermediate format. Here,event is any change such as edges in test vectors or no changes definedrelative to timing. The two cycle-based descriptions will usually besubstantially different from one another. For converting one cycle-baseddescription to another cycle-based description, an interveningevent-based representation is used to decompose the data to basicbuilding blocks. Namely, the input cycle-based format (STIL) isdecomposed into constituent events and these events are reconstructed inthe target description format (TDL).

This basic process is illustrated in FIG. 6A which performs thevector-based to vector-based conversion process. In the presentinvention, the test vectors in the STIL format is decomposed into eachevent which is compared with templates produced based on waveformsdefined in TDL, an example of target test language. This concept isshown by the arrows of dotted lines in FIG. 6A. When match is found fora template, the matched template is listed in a file to which theparameters in the corresponding STIL test vectors are transferred tocomplete the waveform. In this manner, the TDL test vectors are createdas shown by the arrow of dotted line in FIG. 6A.

FIG. 6B is a functional representation of the test vector conversion ofthe present invention from the STIL test language to the TDL testlanguage. An STIL vector file 21 is a file storing STIL test vectors tobe converted to TDL vectors through the conversion process of thepresent invention. Typically, the STIL test vectors in the STIL file 21are derived from the design stage of semiconductor devices, i.e., CAE(Computer-Aided Engineering) environment or EDA (Electronics DesignAutomation) environment as a result of conducting logic simulation. TheSTIL test vectors are decomposed into constituent events and stored in adecomposed event file 24.

As noted above, TDL is a test language developed by AdvantestCorporation, the assignee of the present invention, to establish a logictest pattern (LPAT) file. The format of TDL is stored in a. TDL wavekindfile 22. Each waveform defined in the target test language TDL isconverted to a corresponding template having a set of components. Suchtemplates of waveforms are stored in a template file 25.

A pattern matching is performed by a comparator 26 between the eventsfrom the event file 24 and the templates from the template file 25. Whenmatch is found, the waveform corresponding to TDL is listed in a file 28which stores template matched data representation. Further, the detailsof parameters for the vectors of the matched template are transferredfrom the STIL vectors to the TDL vectors. Such details of the vectorsinclude timings, pattern characters, and types of edge. Thus, in a TDL &LPAT file 29, the TDL test vectors corresponding to the STIL testvectors are created through the conversion process in the foregoing.

As an example, with reference to FIGS. 7 and 8, consider the followingSTIL construct, an equivalent TDL representation and the correspondingwaveforms:

-   -   01{‘400 ns’ D/U;}=>NRZ; T1=400 ns; T2=400 ns        where the STIL construct 01 {‘400 ns’ D/U;} in the left means        that the character ‘0’ specifies a falling edge (D) at 400 ns        while the character ‘1’ specifies a rising edge (U) at 400 ns.        This STIL representation corresponds to the waveforms shown in        the upper part of FIG. 8 and to a non-return zero (NRZ) waveform        defined in TDL. In FIG. 8, the waveform of character ‘0’ shows        the shaded portion from the start edge of a test cycle to the        falling edge T1 at 400 ns from the start edge. The shaded        portion means that the logic state in this area is undefined.        Thus, the character ‘0’ defines the falling edge T1 at 400 ns        from the start of the test cycle whatever the current logic        status is. Similarly, the waveform of the character ‘1’ defines        the rising edge T1 at 400 ns from the start of the test cycle        whatever the current logic status is. As noted above, this        example of STIL construct corresponds to the NRZ waveform of        TDL.

Therefore, in the conversion method of the present invention, theconstruction of TDL waveforms from the decomposed STIL waveformdescriptions is carried out using a template matching method. Thewaveforms available for a given tester are read in at run time andstored in a manner that makes template matching easy. Thus, as a firststep, a list of templates is established for each waveform such as NRZdefined in TDL. The template is characterized by the set of {patterncharacter, starting value, number of subsequent edges} pairs thatdescribe the waveform. The representation of the NRZ waveform in theabove example is shown in the lower part of FIG. 7.

In the example of template in FIG. 7, the first element on each line isthe pattern character while the next two elements represent the{starting value, number of subsequent edges} pairs while the remainingentries indicate the names for the specified edges. Using this, theexample above can be represented using the NRZ waveform with thefollowing values:

-   -   01=>{0,0,0}, {0,1,1 400 ns D}, {1,0,1 400 ns U}, {1,1,0,}        where the {pattern character, starting value, number of        subsequent edges} are shown. Storage of all waveforms defined in        the target test language, in this example TDL, in this manner        allows a simple comparison of the decomposed STIL waveforms        against the capabilities of a given waveform. Thus, the library        of templates is prepared in the template file 25 of FIG. 6B.

In the comparison, the decomposed STIL waveform and the template of TDLare compared with one another. The STIL waveform is decomposed into eachevent which is expressed by a combination of starting value and numberof edges. The data describing the starting value and number of edges ofeach event in the STIL waveform is stored in the event file 24 of FIG.6B. Thus, the comparison between the decomposed events and the templateis made by comparing the starting value and the number of edges. This isdone as a query against the waveforms, essentially asking, “can yousupport this many edges with this starting value?”.

It should be noted that the mapping of an STIL waveform to a templaterequires matching all of the resulting triples that comprise thewaveform. In the example above, the characters ‘01’ from STIL result inthe four triples shown in the template of FIG. 7. All four of these mustbe mapped in order for these characters to be fully represented. Forthis example, the NRZ is capable of supporting all of the requiredtriples.

As another example of basic template matching, consider the followingSTIL characters, TDL representation and waveforms with reference to FIG.8:

-   -   0{ }1{‘200 ns’ U; ‘400 ns’ D;}=>RZ; T1=200 ns; T2=400 ns;        which corresponds to a return zero (RZ) waveform in TDL the        waveforms of which are shown in the center of FIG. 8. Thus, the        template of RZ waveform of TDL is set in the template file 25 of        FIG. 6B.

The template matching examples shown in the preceding section are verysimple. They match directly with standard waveforms, NRZ and RZ. Thesewaveforms may be used on the test equipment running with TDL without anyresource penalty. However, in the real test implementation, more complexwaveforms are also used. Consider the following example:

-   01{‘100 ns’ D; ‘200 ns’ D/U; ‘400 ns’D;} with the waveforms shown in    the lower part of FIG. 8 and an upper half of FIG. 9. This example    means that the character ‘0’ specifies a falling edge at 100 ns, a    falling edge at 200 ns and a falling edge at 400 ns wherein the last    two edges are redundant and will not actually be retained. The    character ‘1’ specifies a falling edge at 100 ns, a rising edge at    200 ns and a falling edge at 400 ns.

The pattern character “0” can be matched by a NRZ or RZ waveform. Thepattern character “1” would require a more complex waveform, such as theXOR (exclusive OR) with values T3=100 ns, T1=200 ns, T2=400 ns. Thereare several reasons why this is an undesirable situation. First, ifthese two characters are actually used in a pattern block (and theirdefinition makes this likely), this will result in an on-the-flywavekind switch. On many ATE systems, this results in a limiting ofavailable resources. Also, on some systems, the use of the XOR waveformin certain situations can result in a reduction in tester resources.Clearly this is not desirable solution to this waveform matchingproblem. Thus, in the following, some tricks will be detailed that canbe used to simplify complex match cases.

Unused Initial Value

In STIL, all of the information about the waveforms that will be used ispresented up front in the WaveformTable construct. Analysis can beperformed on this information to determine characteristics of theavailable wave shapes. This information can be used to make informedoptimization. In this section, the concept of “unused initial value” isexamined to see how this can help with optimization.

First, it should be noted that a set of pattern characters presented toa given signal defines a continuous waveform despite the use of thediscrete characters. Consequently, the starting state experienced by agiven character is based on the ending state produced by the previouscharacter. The set of ending value is, therefore, contained within theinformation in the WaveformTables. The exception to this statement isthe signal starting value, which can be set arbitrarily by the user. Inorder to allow optimization of the template matching algorithm, it isimperative that the user make intelligent choices about starting value.

Referring back to the example shown above, and repeated here: 01 {‘100ns’ D; ‘200 ns’ D/U; ‘400 ns’ D;}, and the corresponding waveforms areshown in FIGS. 8 and 9. It has been already shown that a completetreatment of this set of characters results in undesirable consequences.In analyzing this set of characters, it is known that neither of themends with a “U” (rising) value. Consequently, by initializing the signalwith a “D” (falling) value, and these are the only available characters,the characters never begin any cycle in a “U” state. The waveformdescription shown in the lower left of FIG. 9 reduces (almost) to thatshown in the lower right of FIG. 9. Thus, the simple RZ waveform (T1=200ns; T2=400 ns) can be used to match this set of characters.

Table Based Analysis

With the concept of unused initial value, the mechanism ofWaveformTable-based analysis of the STIL characters is described withreference to the tables of FIGS. 10A and 10B and charts of FIGS. 11 and12. This entails cataloging the requirements of all pattern charactersand forming composite representations of these data at several levels(S11 in FIG. 11). Note that these data need not be compiled across allpins or pin groups, but only within a signal. For each signal, the waveshape requirement data are compiled at three levels (S12 in FIG. 11):

-   -   1. Entire signal    -   2. WaveformTable, and    -   3. Individual pattern character.

Ideally, it would be desirable to characterize the behavior of an entiresignal using a single wavekind, so the data are compiled at this level.Failing this, the next logical level is the WaveformTable. It is assumedthat switching WaveformTables will not happen often during the patterns,very possibly only in going from one pattern block to another.Furthermore, if the switching between pattern blocks occurs at the levelof PatternExec blocks, these will be relegated to different tests in theTDL code and any differences in wavekinds will not result in anon-the-fly switch.

Finally, if the behaviors of the pattern characters within aWaveformTable cannot be represented by a single wavekind, the matchingwill be attempted on an individual character level. If this fails, itmeans that some pattern character in the STIL file contains requirementsthat cannot be satisfied by the test language of the target ATE system.In some cases, more advanced features of the target ATE system can beused to alleviate these problems. In other cases, this is simplyreported as a fatal error in the conversion process.

The data to be stored at each of the levels indicated above is the same:the starting value and number of edges required by the STIL patterncharacters. This is stored in an array whose dimensions are based oncharacteristics of the target ATE system. With use of the “unusedinitial value” technique described above, the capacity of array can besignificantly reduced. The number of drive edges that can be supportedper time set is read in at run time and this is used for one dimensionof the array. The other dimension is two, the number of possiblestarting values “1” or “0” in a binary logic system. Each combination ofstarting value and number of edges that requires support is set to true(T). The rest are false (F).

Thus, for the above example:

-   -   0{ }1{‘200 ns’ U; ‘400 ns’ D;}=>RZO; T1=200 ns; T2=400 ns        the array would look like the table shown in FIG. 10A where it        is assumed that at most four drive edges may be supported per        time set. For another example:    -   23{‘100 ns’ D; ‘200 ns’ D/U; ‘400 ns’ D;}        the table of FIG. 10B now contains an additional entry. This        table describes all of the information about these four waveform        characters. The technique of the unused initial value noted        above can be applied to this table because “1” is the initial        value that will never occur (unless set during initialization).        As a result, the entire column labeled “1” can be set to false,        which results in the same situation as described previously with        reference to the waveforms in the lower left and right of        FIG. 9. This mechanism can be applied to tables created at any        of the levels, i.e, signal, waveform table, and pattern        character, discussed.

The more detailed description regarding the template matching procedureis given here. As described above, the array (matcharray) of decomposedevents each forming a starting value and number of edges is created inthe event file 24 of FIG. 6B to be compared with the counterpartwaveform data in the template file 25. Once the “matcharray” describedabove has been created, and then reduced through the analysis of “unusedinitial values”, the match against the available waveforms is made (S13in FIG. 11). As discussed above, the waveforms available to the targetATE system (read in at run time) are stored based on the starting valueand number of edges they can support in the template file 25. Thestructure in the templates is analogous to the matcharray shown aboveexcept that the entry in each box of tables in FIGS. 10A and 10B is acollection of wavekind object pointers that can satisfy the indicatedcombination of starting value and number of edges.

It should be noted that a given wavekind will appear in several of theselists as they can support a variety of {starting value, number of edge}pairs. For example, the RZO waveform would be found in the {0,0}, {0,2},{1,0} and {1,1} array elements as it can support all of thesecombinations. Note that this refers to the RZO waveform in TDL wherethere is no activity for the pattern character ‘0’. Thus, the {1,0}combination exists. The industry standard RZ waveform would return tozero for both pattern characters ‘0’ and ‘1’, and the {1,0} combinationwould not be possible.

The wavekind object can be queried for all combinations that it cansupport. For example, for accessing the RZO object through the {0,0}entry, the matching process can simply ask the RZO object about othercombinations “can you support {0,2}” which would return true, “can yousupport {1,2}” which would return false. Thus, the matching processwould find the object via the numerically lowest {starting value, numberof edge} pair that was required and then query the object for the restof the desired states. If any of these queries fail, this wavekind willnot work and the matching process goes to the next entry in the originallist and try the process again.

Once a successful match has been made for a given wavekind, the valuesfor parameters must be set (S14 in FIG. 11). The decomposed STILcharacters contain time values for transitions, and the wavekind objectscontain strings for the names of their relevant resources. For the caseof the RZO waveform, the match of the {0,2} case completes with theassociation of the time value 200 ns with the string “T1”, and 400 nswith string “T2”. These pairings are stored in a table corresponding tothe STIL character ‘1’ as defined in the WaveformTable.

The WaveformTable-based analysis method takes advantage of economiesavailable when the source format is cycle-based. The informationregarding the formats that will be used for the entire process isavailable up-front and can be processed, analyzed and optimized beforepattern conversion begins. Once this has been completed, the processingof the vectors becomes very simple. The STIL pattern character isaccessed (S21 in FIG. 12), the previous signal value (stored at the endof the previous cycle) is recalled (S22 in FIG. 12) and these data areused to access the information stored for the {starting value, STILpattern character} pair, i.e. the wavekind and parameter informationdetermined from the matching process (S23 and S24 in FIG. 12). Then, theending value is stored for beginning of the next cycle (S25 in FIG. 12).

This is markedly different from the situation where the source format isevent-based, for example, VCD (Value Change Dump) data by Verilog. Inthis case, the wave format information is usually not available upfront. Matching of source data to target wave shapes must be done as thevectors are processed. This can lead to poor choices that are avoidedusing proper table analysis techniques.

Assuming the following two cycles in a waveform: If the templatematching were done on a cycle-by-cycle basis (as would be the normalcase without a table-based analysis), the first cycle would likely endup being mapped to NRZ; this is the simplest waveform that can satisfythe constraints. The second cycle is clearly RZO. If it were known aboutthe second cycle when processing the first, it would have noted that thefirst cycle can also be mapped to RZO, and would have prevented anon-the-fly wavekind switch. A table-based analysis approach providesjust this capability.

Output Signal Conversion

The preceding description has focused on the mapping of input STILcharacters to TDL equivalents. The “input” here means a test patternsupplied (drive) to a pin of device under test (DUT). As previouslynoted, the test vectors include the test patterns (input) and strobes(output or compare). A strobe is a timing pulse either with edge (nopulse width) or window (predetermined pulse width) to sample the deviceoutput signal. Here, the output mapping strategies are described whichdeals with conversion of strobe signals (compare) in the STIL format tothe TDL format. The behaviors specified in the STIL file can be directlytranslated to pattern characters. For example:

-   LHZX{‘0 ns’ Z; ‘0 ns’ X; ‘260 ns’ L/H/T/X;}    can be mapped directly to edge strobes for the appropriate value, if    all are applicable. In other words, the template matching is    unnecessary in this process. Similarly:-   LHZX{‘0 ns’ Z; ‘0 ns’ X; ‘260 ns’ l/h/t/x; ‘500 ns’ x}    can be mapped to the appropriate window strobe.

There are several points worth noting about the output conversion. Thefirst is that some ATE may not allow switching of strobe typeon-the-fly. Thus, edge and window strobes may not be mixed. A solutionin this case is to make all strobes into window strobes, with edgestrobes made into window strobes as narrow as allowed by the system. Thesecond point is that STIL pattern characters that request multiplestrobes within a cycle may or may not be compatible with the target ATEsystem. The capabilities of the ATE system family is built into theconversion tool with a resource file read at run time to indicate whichsubset of these features is actually present on a given target ATEsystem. This would include behaviors such as transition and doublestrobe modes.

Bidirectional Signal Conversion

Bidirectional signal conversion provides the most complexity in theentire process. Here, the term “bidirectional” means conversion of testlanguage from the STIL formate to the native language format for thetest vectors assigned to device pin which functions both input andoutput. All of the features required for input and output matching notedabove are present as well as additional features unique to bidirectionalsignals. In addition, bidirectional signals often place limitations ontester resources above and beyond those placed by simple input or outputsignals. As an example, the number of available edges may be reduced dueto the need for driver control signals to determine the directionalstate of the bidirectional signal.

The considerations for driver control are based on the characteristicsof the STIL pattern characters and the capabilities of the target ATEsystem. A standard paradigm is to provide two driver enable modes, onethat mimics the NRZ behavior, and one for RZ. In the former case, thecycle becomes “drive” (input) at some point and remains that way throughthe end of the cycle. For the RZ, the cycle becomes “drive” and then“compare” (output) during the cycle. Note that the cycle being in“compare” mode does not mean that a comparison is actually taking place,just that the pin is to be treated as an output. This distinctionbecomes important with regard to target ATE capabilities for drive andcompare in a cycle.

The driver enable mode is determined from the STIL patterncharacteristics by noting that an NRZ driver enable mode is preferredsince it requires fewer tester resources. This mode is chosen unlessspecifically required to use the RZ mode. This only happens when a“drive” region is surrounded by “compare” regions in the same cycle.Again, actual comparisons may not be occurring, but the device pin isacting as an output. The time values for the driver control edges aredetermined from the transition times for the signal direction.

The inclusion of driver type information makes the “matcharray” processdescribed above quite a bit more complex. The drive portions of thesignal are matched against the available waveforms while the overallcharacter of a cycle, in terms of “drive” and “compare” portions arecompared against the capabilities of the target ATE system.

STIL contains the concept of the “DrivePrior” event. This is meant tocontain the most-recently-used drive value on a system. For inputsignals, the prior drive value is always the last state of the signal,so this need not be considered. Output signals have no drive states, sothis is irrelevant. Thus, the DrivePrior is only relevant forbidirectional signals where it represents the last drive state attainedby the signal, regardless of any intervening strobe activity. On someATE systems, the presence of a strobe character affects the state of thedriver in the system. For example, if the last “drive” state is “D”, andthis is followed by a strobe for “H”, the driver can be set to a “U”state for the next drive cycle. The “DrivePrior” is intended to handlethis case. With regard to the conversion process, this prior state mustbe kept as well as the actual current state of the driver. The result ofthis is that the “matcharray” shown above contains four columns insteadof two, corresponding to all possible pairs {previous value,DrivePrior}, i.e., the column heads (FIGS. 10A and 10B) are {0,0},{0,1}, {1,0}, {1,1}.

The data used in these entries must be used properly in order for theconcept of the “DrivePrior” to work properly. The desired initial state,as given by the “DrivePrior” value, must be reconciled with the actualstate of the driver, previous value. Using the example above, the driveris in the “U” state, and the STIL pattern character is requesting thedevice to be in the “D” state based on the inclusion of the “DrivePrior”or “P” event in the description. The waveform chosen to match thispattern character must be able to reconcile these values, driving thepin from the “U” state to the “D” state by the time required. This canresult in an additional edge not readily apparent from the STIL patterncharacter description.

Special Features

In the following, the test language conversion is further discussed asto the processing of special features provided in the target ATE system.These features represent those found on the assignee's ATE system,Advantest Model T6600 IC tester family, but they are quite general andmay be found, in some form, on a variety of test systems. Thus, briefdiscussion is made as to the algorithms used to map the STIL informationto these features.

Multi-Clock Signals

The multi-clock (MCLK) signal type is commonly used for providing morepulses per cycle thin the ATE system can theoretically provide. This isdone for repetitive waveforms by essentially breaking the tester cycleinto a series of subcycles (internally) and providing multiple copies ofa basic waveform, one per subcycle. The result is the appearance of agreater number of edges than possible in the rated test cycle.

The key to the use of the MCLK paradigm is that the waveform mustcontain a basic repeatable unit within the cycle. During the templatematching algorithm described above, the discovery that a STIL patterncharacter contains too many edges leads to an attempt to match thecharacter using an MCLK format. For this to work, the number of edgesmust be even (the MCLK format is pulse-based). The constraints that mustbe satisfied for a single-pulse repeatable waveform are derived withregard to an upper waveform of FIG. 13.

In order to have a repeatable unit, it is required that the widths ofall pulses be the same. Furthermore, the spacing between the pulses mustbe equal to the sum of the space (A) before the first pulse plus thespace (B) at the end of the last pulse, as shown. This means that it isnecessary to have a basic repeatable unit that looks like RZ with T1=A,T2=A+PW, and a subcycle length of A+PW+B. If any of these conditions arenot met it is unable to provide a single pulse basic repeatable unit.

It is possible to create a double-pulse basic repeatable unit. Therequirements are derived based on the lower waveform of FIG. 13. In thiscase there are two pulses per repeatable block, and it requires that thecorresponding pulses be the same width, in this case the pulses labeledPW1 and PW2. The sum of the begin and end space must match the intervalbetween the repeatable unit repetitions, as above (repeatable unitspace=A+B). Also, the spacing (C) between the pulses must be the samefor all repeatable units. Thus, in this case, a subcycle length isA+PW1+C+PW2+B.

Pin Multiplexing

In the pin multiplexing (PMUX), two tester channels are combined todrive a single pin. This allows the resources for both tester channelsto be used for the same signal, enabling drive (input) and compare(output) in the same cycle on ATE systems where this might not otherwisebe available.

While the use of PMUX can make the ATE programming task easier, it addscomplication to the conversion process by providing an additional degreeof freedom. While this might seem desirable in that it providesflexibility, it makes the search of the wavekind space a little harderbecause requirements are not precisely pinned down. In the following,discussion will be made as to the implications of PMUX on the variouspin types.

(1) Input PMUX

Input pin mapping is performed by a search of the wavekind spaceattempting to match the capabilities of the wavekind with therequirements of the STIL pattern character. The details of this approachhave been discussed above. When an input signal is used with PMUX, theresponsibility for matching the requirements of the STIL patterncharacter is shared between the two tester channels. The issue presentedby the added flexibility is one of determining a “requirement sharing”methodology.

One approach taken is that the simplest sharing algorithm is not toshare at all. If possible, one pin does all the work and the other doesnone. To this end, an attempt is made to map all of the edges specifiedby the STIL pattern character into the first tester channel. Thematching that takes place here is identical to that described above fornon-PMUX input signals. The difference occurs if the match attemptfails, i.e. there is no wavekind that can satisfy some subset of a STILpattern character's requirements. Previously, this situation eitherresulted in an attempt to use MCLK, or the reporting of an error. Withthe PMUX case, one edge is shifted from the first channel to the second,and the match is attempted for the first channel and second channelseparately. The shifting of edges is continued until a match is possiblefor both channels for all sets of requirements for the STIL patterncharacter.

Adding to the complication for this algorithm is the need to maintaincontinuity between the two component channel behaviors. A given channel“remembers” its final state from the last cycle. The state of the driverto the device, however, has been set by the signals from the otherchannel. For example, if channel 1 drives the pin to an “H” state, itwill have “H” as its previous state. Now, suppose channel 2 drives thepin to a “L” state. When channel 1 drives again, it will “remember”being in the “H” state, but the driver will actually be in the “L” statebecause of the action of channel 2. Coordination between the twochannels comprising the signal is required to prevent this situation.

As an example, consider the following signal of the uppermost waveformin FIG. 14, where T₀ denotes a cycle boundary. This signal is verysimple and appears to have a NRZ character for the first signal. Infact, the second signal apparently needs to do nothing except stay low.Consider the first pass solution to this problem, shown in FIG. 14.

The signal proposed for Channel (Pin) 1 provides the rising edge atT_(a), as desired (second waveform from the top in FIG. 14). Since thereare no edges in the second portion of the signal, Pin 2 need have noedges (third waveform from the top in FIG. 14). In the second cycle, Pin1 remains high as there are no edges. In the second part of the cycle,there is a low-going edge. Since Pin 2 is already in the “L” state, noedge will be generated.

It is clear from this example that the simple approach will not work inthis case. The signal will look exactly like the waveform on Pin 1 asPin 2 has no edges. This has happened because the continuity acrosschannels has not been maintained. Pin 2 needs to be aware that Pin 1 hasended in an “H” state so that subsequent edges on the system, in thiscase the transition to “L” at T_(a) in the second cycle, will be handledproperly. This can be accomplished by replacing the waveform for Pin 2above with that shown in the bottom of FIG. 15.

Here the waveform for Pin 2 is brought to the “H” state at the splittime. This will have no effect on the composite signal as the driver isalready in the “H” state due to the action of Pin 1. It does, however,condition Pin 2 to be in a consistent state with Pin 1. When thelow-going edge happens in the second cycle during the Pin 2 portion thiswill result in a low-going transition on Pin 2 at T_(b) as desired. Thisdemonstrates the channel consistency problem that must be handled forPMUX signals.

(2) Output PMUX

As with normal pattern matching, the conversion of output signals in thepresence of PMUX is simpler than input conversion. The cycle is splitinto two portions, and strobe edges are assigned to the two channels(pins) based on their position relative to the split time. Forsimplicity, the split time is chosen as the middle of the period. Strobeedges occurring before this time are assigned to the first channel, andthose occurring after are assigned to the second. One notable exceptionto this rule is window strobes. These may not be split across theboundary between channels. Consequently, the split time is chosen sothat the entire window strobe falls within one of the channels.

(3) Bidirectional PMUX

The use of PMUX with bidirectional signals allows features that mightnot otherwise be available. This is a primary use for the PMUXconstruct, rather than for pure input or output signals. Probably thesingle most important use of the PMUX is to allow drive and comparewithin a cycle, if the target ATE system does not allow this. For caseswhere a STIL pattern character for a bidirectional signal specifies puredrive or compare behavior for a cycle, the processing is virtuallyidentical to that described with respect to the input and output pinmultiplexing above. When the behavior is mixed, the split time fordividing the cycle between the channels is based on the time of thedirection switch. This leads to a very natural division of theresponsibilities of the two channels. The concept of continuity acrosschannels that we discussed for input signals applies here as well, butmust also take into account the effects of intervening strobes.

As has been described above, according to the present invention, thetest vectors in an original test language are converted to a target testlanguage with high efficiency and high accuracy.

Although only a preferred embodiment is specifically illustrated anddescribed herein, it will be appreciated that many modifications andvariations of the present invention are possible in light of the aboveteachings and within the purview of the appended claims withoutdeparting the spirit and intended scope of the invention.

1. A method of converting test vectors in an original cycle based testlanguage into a target cycle based test language, comprising thefollowing steps of: reading available waveforms defined in the targettest language and forming a set of templates depicting the waveformswhere each template corresponds to a waveform of the target testlanguage and includes data showing at least a starting value of asegment of waveform and a number of subsequent edges in the waveform;reading the test vectors of the original test language and decomposing awaveform in the test vectors in the original test language into a set ofconstituent events where each event includes data showing at least astarting value and a number of subsequent edges of the waveform;comparing the template derived from the waveform in the target testlanguage and the set of constituent events derived from the originaltest language; storing the waveform data in the target test languagewhen a match is detected in the comparison step and retrievingcorresponding parameters of the waveform in the test vectors of originaltest language and storing the parameters in combination with the matchedwaveform data; repeating the above steps for all of the test waveformsin the original test language, thereby forming representation of thewaveforms in the target test language; wherein the step of comparing thetemplate and the constituent event is made at different levels ofabstraction determined in advance, in the order of a signal level, awavekind level where the signal is configured by a plurality ofwavekinds, and a character level where the wavekind is configured by aplurality of characters.
 2. A method of converting test vectors asdefined in claim 1, wherein the set of constituent events is stored in atable format having columns assigned to the data showing the number ofsubsequent edges and the starting value.
 3. A method of converting testvectors as defined in claim 2, wherein the table storing the set ofconstituent events is optimized by studying the starting value of aparticular event based on an ending state produced by the previousevent, thereby simplifying the data in the table.
 4. A method ofconverting test vectors as defined in claim 1, wherein the test vectorsincludes drive signals to be supplied to a device under test (DUT) as aninput and strobe signals to sample an output of DUT for evaluation,wherein the drive signals in the original test language are converted tothe target test language by comparing the template and the set ofconstituent events for detecting the match while the strobe signals inthe original test language are directly translated to the target testlanguage.
 5. A method of converting test vectors as defined in claim 1,wherein the waveforms in the original test language are assigned whererequired by resource limitations to a plurality of subcycles of thetarget test language where the plurality of subcycles are created bymultiplexing a test cycle clock in a test system which is operated bythe target test language.
 6. A method of converting test vectors asdefined in claim 1, wherein the waveforms in the original test languageare assigned to a plurality of test channels of the target test languagewhere the plurality of test channels are multiplexed to be connected toa single pin of DUT in a manner configured by a test system which isoperated by the target test language.
 7. A method of converting testvectors in a STIL (Standard Test Interface Language) into a target cyclebased test language, comprising the following steps of: readingavailable waveforms defined in the target test language and forming aset of templates depicting the waveforms where each template correspondsto a waveform of the target test language and includes data showing atleast a starting value of a segment of waveform and a number ofsubsequent edges in the waveform; reading the test waveforms of the STILformat and decomposing a waveform in the test vectors in the STIL formatinto a set of constituent events where each constituent event includesdata showing at least a starting value and a number of subsequent edgesof the waveform; comparing the template derived from the waveform in thetarget test language and the set of constituent events derived from thewaveform in STIL; storing the waveform data in the target test languagewhen a match is detected in the comparison step and retrievingcorresponding parameters of the waveform in the test vectors of STIL andstoring the parameters in combination with the matched waveform data;repeating the above steps for all of the test vectors in STIL, therebyforming a test vector file of the target test language; wherein the stepof comparing the template and the constituent event is made at differentlevels of abstraction determined in advance, in the order of a signallevel, a wavekind level where the signal is configured by a plurality ofwavekinds, and a character level where the wavekind is configured by aplurality of characters.